/*
 * @Author: Await
 * @Date: 2025-05-08 18:02:00
 * @LastEditors: Await
 * @LastEditTime: 2025-05-09 18:45:00
 * @Description: 图表数据转换工具函数
 */

import { ChartType, ChartConfig } from '../../types/chartTypes';
import { DataItem, DataConfig } from '../../types/dataTypes';
import { logDebug, logWarning } from './commonUtils';
import { ensureConfigCompleteness } from '../../components/Charts/ChartBase/ensureConfigCompleteness';

/**
 * 将数据项转换为ECharts需要的格式
 * @param data 原始数据数组
 * @param dataConfig 数据配置
 * @returns 转换后的数据数组
 */
export const transformData = (data: DataItem[], dataConfig: DataConfig): any[] => {
    if (!data || !data.length || !dataConfig) {
        logWarning('数据或数据配置为空，无法转换');
        return [];
    }

    logDebug('开始数据转换', { dataConfig });

    try {
        // 检查是否使用dimensions和measures配置
        if (dataConfig.dimensions?.length > 0 || dataConfig.measures?.length > 0) {
            logDebug('使用dimensions和measures配置');
            return transformDataWithDimensionsAndMeasures(data, dataConfig);
        }

        // 使用传统方式处理
        const { category, value, series } = dataConfig;

        // 如果没有指定映射字段，尝试使用常见字段名
        if (!category && !value) {
            logDebug('未指定映射字段，尝试使用常见字段名');
            return data.map(item => {
                if (typeof item !== 'object' || item === null) return { value: item };

                // 尝试寻找常见的名称和值字段
                const nameField = ['name', 'category', 'label', 'x'].find(field => item[field] !== undefined);
                const valueField = ['value', 'count', 'y', 'amount'].find(field => item[field] !== undefined);

                return {
                    name: nameField ? item[nameField] : '未命名',
                    value: valueField ? item[valueField] : 0
                };
            });
        }

        // 转换后的数据
        return data.map(item => {
            // 如果数据源是对象数组
            if (typeof item === 'object' && !Array.isArray(item)) {
                // 基本数据结构
                const result: any = {};

                // 设置数据名称/类别
                if (category && item[category] !== undefined) {
                    result.name = item[category];
                } else if (item.name !== undefined) {
                    result.name = item.name;
                }

                // 设置数据值
                if (value && item[value] !== undefined) {
                    result.value = item[value];
                } else if (item.value !== undefined) {
                    result.value = item.value;
                }

                // 设置系列
                if (series && item[series] !== undefined) {
                    result.series = item[series];
                }

                // 添加其他需要的属性
                if (dataConfig.extraFields) {
                    dataConfig.extraFields.forEach(field => {
                        if (item[field] !== undefined) {
                            result[field] = item[field];
                        }
                    });
                }

                return result;
            }
            // 如果数据源已经是数组格式，直接返回
            return item;
        });
    } catch (error) {
        logWarning('数据转换失败:', error);
        return [];
    }
};

/**
 * 使用维度和度量配置转换数据
 */
const transformDataWithDimensionsAndMeasures = (data: DataItem[], dataConfig: DataConfig): any[] => {
    if (!dataConfig.dimensions?.length && !dataConfig.measures?.length) {
        return data;
    }

    logDebug('维度和度量转换', {
        dimensions: dataConfig.dimensions,
        measures: dataConfig.measures
    });

    // 处理维度和度量的数据映射
    return data.map(item => {
        const result: any = {};

        // 处理维度字段
        if (dataConfig.dimensions?.length > 0) {
            dataConfig.dimensions.forEach(dim => {
                if (dim.field && item[dim.field] !== undefined) {
                    // 使用维度配置的字段名作为属性名，或者使用别名
                    const propName = dim.field;
                    result[propName] = item[dim.field];

                    // 如果这是分类维度，同时设置为name属性
                    if (dim.xAxis || dim.category) {
                        result.name = item[dim.field];
                    }
                }
            });
        }

        // 处理度量字段
        if (dataConfig.measures?.length > 0) {
            dataConfig.measures.forEach(measure => {
                if (measure.field && item[measure.field] !== undefined) {
                    // 使用度量配置的字段名作为属性名，或者使用别名
                    const propName = measure.field;
                    result[propName] = item[measure.field];

                    // 如果这是主要度量，同时设置为value属性
                    if (measure.primary) {
                        result.value = item[measure.field];
                    }
                }
            });

            // 如果没有找到标记为primary的度量，使用第一个度量作为value
            if (result.value === undefined && dataConfig.measures[0]?.field) {
                result.value = item[dataConfig.measures[0].field];
            }
        }

        // 确保同时有name和value属性
        if (result.name === undefined) {
            result.name = item.name || `项目${Object.keys(result).join('-')}`;
        }

        if (result.value === undefined) {
            result.value = item.value || 0;
        }

        return result;
    });
};

/**
 * 根据图表类型处理特定的数据格式
 * @param type 图表类型
 * @param data 数据数组
 * @returns 处理后的数据
 */
export const processDataByChartType = (type: ChartType, data: any[]): any[] => {
    if (!data || !data.length) return [];

    switch (type) {
        case ChartType.PIE:
            // 饼图数据需要有name和value
            return data.map(item => {
                if (Array.isArray(item)) {
                    return { name: item[0], value: item[1] };
                }
                return item;
            });

        case ChartType.BAR_3D:
        case ChartType.SCATTER_3D:
        case ChartType.LINE_3D:
            // 3D图表数据必须是[x, y, z]格式
            return data.map((item, index) => {
                // 已经是数组格式的情况
                if (Array.isArray(item)) {
                    // 检查数组长度
                    if (item.length === 3) {
                        // 确保所有值都是数字
                        return item.map(val => typeof val === 'number' ? val : parseFloat(val) || 0);
                    } else if (item.length === 2) {
                        // 只有x, y值，添加一个z值
                        const x = typeof item[0] === 'number' ? item[0] : parseFloat(item[0]) || 0;
                        const y = typeof item[1] === 'number' ? item[1] : parseFloat(item[1]) || 0;
                        return [x, y, 10 + index]; // 默认z值可根据索引变化
                    } else if (item.length === 1) {
                        // 只有一个值的情况
                        const x = typeof item[0] === 'number' ? item[0] : parseFloat(item[0]) || 0;
                        return [x, 0, 10 + index]; // 默认y, z值
                    } else if (item.length > 3) {
                        // 数组超长，只取前三个值
                        return item.slice(0, 3).map(val => typeof val === 'number' ? val : parseFloat(val) || 0);
                    } else {
                        // 空数组情况，提供默认值
                        return [index, 0, 10];
                    }
                }

                // 对象格式的情况
                if (item && typeof item === 'object') {
                    if ('x' in item && 'y' in item && 'z' in item) {
                        // 已有x,y,z属性
                        const x = typeof item.x === 'number' ? item.x : parseFloat(item.x) || 0;
                        const y = typeof item.y === 'number' ? item.y : parseFloat(item.y) || 0;
                        const z = typeof item.z === 'number' ? item.z : parseFloat(item.z) || 0;
                        return [x, y, z];
                    } else if ('name' in item && 'value' in item) {
                        // 有name和value的常见格式
                        if (Array.isArray(item.value) && item.value.length >= 2) {
                            // value是数组，提取前两个值作为x,y，添加index作为z
                            const x = typeof item.value[0] === 'number' ? item.value[0] : parseFloat(item.value[0]) || 0;
                            const y = typeof item.value[1] === 'number' ? item.value[1] : parseFloat(item.value[1]) || 0;
                            const z = item.value.length > 2 ?
                                (typeof item.value[2] === 'number' ? item.value[2] : parseFloat(item.value[2]) || 0) :
                                (typeof item.value === 'number' ? item.value : 10 + index);
                            return [x, y, z];
                        } else {
                            // value不是数组或长度不足
                            return [index, 0, typeof item.value === 'number' ? item.value : parseFloat(item.value) || 10];
                        }
                    } else {
                        // 其他对象情况，尝试从各种可能的属性中提取数据
                        const x = parseFloat(item.x || item.X || item.lng || item.longitude || item.lon || index) || 0;
                        const y = parseFloat(item.y || item.Y || item.lat || item.latitude || 0) || 0;
                        const z = parseFloat(item.z || item.Z || item.value || item.val || 10 + index) || 0;
                        return [x, y, z];
                    }
                }

                // 基本类型情况
                if (typeof item === 'number') {
                    return [index, 0, item]; // 数字直接作为z值
                }

                if (typeof item === 'string') {
                    const num = parseFloat(item);
                    if (!isNaN(num)) {
                        return [index, 0, num]; // 可转换为数字的字符串
                    }
                }

                // 默认情况，创建基础数据点
                return [index, 0, 10 + (index % 5)]; // 创建波浪效果的默认值
            });

        case ChartType.GRAPH:
            // 关系图特殊处理：将普通数据转换为节点和边的结构
            logDebug('处理关系图特殊数据结构');

            // 如果已经是关系图格式，直接返回
            if (data[0] && (data[0].source !== undefined || data[0].target !== undefined ||
                data[0].nodes !== undefined || data[0].links !== undefined)) {
                logDebug('关系图数据已经符合格式，无需转换');
                return data;
            }

            // 创建中心节点
            const centerNode = { id: 'center', name: '中心', symbolSize: 40, value: 100 };
            const nodes = [centerNode];
            const edges = [];

            // 将每个数据点作为周围的节点
            data.forEach((item, index) => {
                const nodeId = `node${index}`;
                let nodeName = '';
                let nodeValue = 0;

                // 尝试获取名称和值
                if (typeof item === 'object') {
                    nodeName = item.name || `节点${index + 1}`;
                    nodeValue = typeof item.value === 'number' ? item.value : 50;
                } else if (typeof item === 'number') {
                    nodeName = `节点${index + 1}`;
                    nodeValue = item;
                } else {
                    nodeName = String(item);
                    nodeValue = 50;
                }

                // 创建节点
                nodes.push({
                    id: nodeId,
                    name: nodeName,
                    symbolSize: 20 + nodeValue / 10,
                    value: nodeValue
                });

                // 创建从中心到该节点的边
                edges.push({
                    source: 'center',
                    target: nodeId,
                    value: nodeValue
                });
            });

            // 返回转换后的数据
            return { nodes, links: edges };

        default:
            return data;
    }
};

/**
 * 转换数据到图表选项
 * 根据图表类型和数据配置，处理数据并更新到图表配置中
 * @param config 图表配置
 * @param data 数据项数组
 * @param dataConfig 数据配置
 * @returns 应用数据后的图表配置
 */
export const transformDataToOption = (config: ChartConfig, data: DataItem[], dataConfig: DataConfig): ChartConfig => {
    // 记录调试信息
    logDebug('transformDataToOption调用', {
        configType: config?.type || config?._originalType,
        dataLength: data?.length,
        dataConfigExists: !!dataConfig,
        firstDataItem: data && data.length > 0 ? data[0] : null
    });

    // 修改判断逻辑，更宽松地处理空数据的情况
    if (!config) {
        logWarning('图表配置为空，无法应用数据');
        return config;
    }

    // 检查是否为雷达图 - 处理雷达图的特殊情况，使用明确的判断条件
    const isRadarChart = (
        config._originalType === 'radar' ||
        (config.series &&
            Array.isArray(config.series) &&
            config.series.length > 0 &&
            config.series[0]?.type === 'radar')
    );

    // 判断目标图表类型
    const targetChartType = config._originalType ||
        (config.series &&
            Array.isArray(config.series) &&
            config.series.length > 0 &&
            config.series[0]?.type) ||
        config.type;

    // 处理目标图表类型为雷达图的情况
    if (targetChartType === 'radar') {
        logDebug('处理雷达图特有配置');
        // 雷达图特有配置处理，这部分将移动到radarCharts.ts中
        // 此处创建基本配置返回
        return config;
    }

    // 检查是否切换到雷达图的情况
    const isChangingToRadar = (
        targetChartType === 'radar' &&
        config._originalType !== 'radar' &&
        (config.type !== 'radar' || !config.radar)
    );

    if (isChangingToRadar) {
        logDebug('检测到从其他类型切换到雷达图的情况，执行特殊处理');
        // 这部分将移动到radarCharts.ts中
        // 此处创建基本配置返回
        return config;
    }

    // 检查是否从雷达图切换到其他类型的情况
    const isChangingFromRadar = (
        (config._originalType === 'radar' &&
            targetChartType !== 'radar' &&
            targetChartType !== undefined) ||
        (config.radar !== undefined &&
            targetChartType !== undefined &&
            targetChartType !== 'radar') ||
        (config.series &&
            Array.isArray(config.series) &&
            config.series.length > 0 &&
            config.series[0]?.type === 'radar' &&
            targetChartType !== undefined &&
            targetChartType !== 'radar')
    );

    if (isChangingFromRadar) {
        logDebug('检测到从雷达图切换到其他类型的情况，执行彻底清理');
        // 这部分将移动到图表类型转换处理的文件中
        // 此处创建基本配置返回
        return config;
    }

    // 如果没有数据或数据配置，仍然返回基本图表结构
    if (!data || !data.length || !dataConfig) {
        logWarning('数据或数据配置为空，返回基本图表结构');
        return ensureConfigCompleteness({
            ...config,
            series: config.series || [{ type: config.type, data: [] }]
        });
    }

    try {
        // 转换基础数据格式
        const transformedData = transformData(data, dataConfig);
        logDebug('数据转换结果:', transformedData);

        // 根据图表类型进一步处理数据
        const processedData = processDataByChartType(config.type as ChartType, transformedData);
        logDebug('图表类型处理后的数据:', processedData);

        // 克隆配置对象，避免修改原始对象
        const result = { ...config };

        // 确保series存在且为数组
        if (!result.series) {
            result.series = [{ type: result.type, data: [] }];
        } else if (!Array.isArray(result.series)) {
            result.series = [result.series];
        }

        // 将数据应用到系列中
        if (result.series.length > 0) {
            // 如果有多个系列，尝试根据系列名称分配数据
            if (result.series.length > 1 && dataConfig.series) {
                // 按系列分组数据
                const seriesMap = new Map<string, any[]>();

                processedData.forEach(item => {
                    const seriesName = item.series || 'default';
                    if (!seriesMap.has(seriesName)) {
                        seriesMap.set(seriesName, []);
                    }
                    seriesMap.get(seriesName)!.push(item);
                });

                // 将数据分配给对应的系列
                result.series.forEach((series, index) => {
                    const seriesName = series.name || `series_${index}`;
                    if (seriesMap.has(seriesName)) {
                        series.data = seriesMap.get(seriesName);
                    } else if (index === 0 && seriesMap.has('default')) {
                        // 默认系列
                        series.data = seriesMap.get('default');
                    }
                });
            } else {
                // 单系列情况，根据图表类型特殊处理
                if (config.type === ChartType.GRAPH && typeof processedData === 'object' && processedData !== null) {
                    logDebug('关系图特殊数据处理');

                    // 安全检查：确保series[0]存在
                    if (result.series && result.series.length > 0) {
                        // 设置graph类型
                        result.series[0].type = 'graph';

                        // 检查是否是包含nodes和links的特殊格式
                        if (!Array.isArray(processedData) &&
                            processedData.nodes &&
                            Array.isArray(processedData.nodes) &&
                            processedData.links &&
                            Array.isArray(processedData.links)) {

                            // 将节点和边数据应用到关系图
                            result.series[0].data = processedData.nodes;
                            result.series[0].links = processedData.links;

                            logDebug('应用关系图数据成功', {
                                nodes: processedData.nodes.length,
                                links: processedData.links.length
                            });
                        } else {
                            // 如果是普通数据，作为节点数据使用
                            result.series[0].data = Array.isArray(processedData) ?
                                processedData :
                                [{ id: 'center', name: '中心', symbolSize: 40, value: 0 }];

                            // 确保links存在
                            if (!result.series[0].links || !Array.isArray(result.series[0].links)) {
                                result.series[0].links = [];
                            }
                        }

                        // 确保data存在，防止undefined错误
                        if (!result.series[0].data || !Array.isArray(result.series[0].data)) {
                            result.series[0].data = [{ id: 'center', name: '中心', symbolSize: 40, value: 0 }];
                        }
                    }
                } else {
                    // 其他图表类型直接赋值
                    result.series[0].data = processedData;
                }
            }
        }

        // 应用配置完整性检查，确保根据图表类型有必要的配置项
        const finalResult = ensureConfigCompleteness(result);

        logDebug('最终生成的图表配置:', finalResult);

        // 在函数末尾返回结果前添加对关系图的特殊处理
        if (config.type === ChartType.GRAPH) {
            logDebug('清理关系图配置，移除不适用的坐标系属性');
            return cleanGraphConfig(finalResult);
        }

        return finalResult;
    } catch (error) {
        logWarning('应用数据到图表配置失败:', error);
        // 即使失败，也提供基本配置
        return ensureConfigCompleteness({
            ...config,
            series: config.series || [{ type: config.type, data: [] }]
        });
    }
};

const cleanGraphConfig = (config: any): any => {
    // 创建配置副本避免修改原始对象
    const cleanedConfig = { ...config };

    // 移除不适用于关系图的配置
    delete cleanedConfig.xAxis;
    delete cleanedConfig.yAxis;
    delete cleanedConfig.grid;
    delete cleanedConfig.axis;

    // 确保tooltip使用item模式
    if (cleanedConfig.tooltip) {
        cleanedConfig.tooltip.trigger = 'item';
    } else {
        cleanedConfig.tooltip = { trigger: 'item' };
    }

    return cleanedConfig;
};
